# #字符串
# str1="abc"
# #列表
# l=[1,2,3]
# #元组
# t=(1,2,3)
# #字典
# d={"sz":1,"xc":2}
#
# #集合 #无序的 不可随机访问，不可重复
# s={1,2,3}
#
# #set 可变集合 增删改
# #frozenset 不可变集合 创建好之后，无法增删改

#集合定义
# s={1,2,3}
# print(s,type(s))

# s2=set("abc")
# s2=set([1,2,3])
#

# s2=set((1,2,3))
# s2=set({"name":18,"age":18})
# print(s2,type(s2))

# s=set(x**2 for x in range(0,10) if x%2==0)
# print(s,type(s))


#可变集合
# fs=frozenset("abc")
# fs=frozenset([1,2,3])
# fs=frozenset((1,2,3))
# fs=frozenset({"name":"sz","age":18})
# print(fs,type(fs))

# s=frozenset(x**2 for x in range(1,10) if x%2==0)
# print(s,type(s))

# s={}  #创建空集合不能用s={}  会被识别成字典 用set()或frozenset()
# s=set()
# s=frozenset()
# print(type(s))

# s={1,2,3,{"name":12}}
# s={1,2,1}
# print(s,type(s))

# l=[1,2,3,3,3]
# s=set(l)
# print(s,type(s))
# result=list(s)
# print(result,type(result))


#可变集合 增删改查
# s={1,2,3}
# # s.add(4)
# s.add([1,2])#error
# print(s,type(s))

# s={1,2,3}
# result=s.remove(2)
# print(result,s)

# s={1,2,3}
# result=s.discard(12)#s.discard 和 s.remove的区别删除没有的前者do nothing 后者报错
# result=s.pop()#s.pop随机删除并返回一个集合中的元素 若集合为空，则返回一个错误
#
# result=s.pop()
#
# result=s.pop()
# # result=s.pop()
#
# print(result,s)

# result=s.clear()#清空一个集合中所有元素

# del s

# print(result,s)
# print(s)

#元素为不可变类型，不能修改

#查 #无法通过索引或key进行查询
# s={1,2,3}
# s=frozenset([1,2,3])
# print(s,type(s))
# for i in s:
#     print(i)

#生成一个迭代器
# its=iter(s)

#使用这个迭代器去访问（next(),for in）
# print(next(its))
# print(next(its))
# print(next(its))
# print(next(its))



#交集
# intersection(Iterable)
          #字符串
                #只判断字符串中的非数字
          #列表
          #元组
          #字典
                #值判定key
          #集合

# 逻辑‘&’
#intersection_update(..)
#交集计算完毕后，会再次赋值给原对象
#会更改原对象
#所以，只适用于可变集合

# s1={"1","2","3","4","5"}
# s1=frozenset([1,2,3,4,5])
# s2={4,5,6}
#可变与不可变集合混合运算，返回结果类型以运算符左侧为主
# result=s2.intersection_update(s1)
# result=s1 & s2
# print(result,type(result))
# print(s1,s2)

# print(s1.intersection("123"))
# print(s1.intersection(["1","2","6"]))
# print(s1.intersection({"1":"abc", "2":"12","6":12}))
# print(s1.intersection(["1","2",["1","2"]]))
# print(s1.intersection(["1","2",("1","2")]))#里面得可哈希

#不可变数据类型‌：整数、浮点数、布尔值、字符串、元组等都是不可变数据类型，因此它们是可哈希的。
#可变数据类型‌：列表、字典、集合等是可变数据类型，因此它们是不可哈希的

#并集
#union() 返回并集
# |     返回并集
#update()  更新并集

# s1={1,2,3}
# s1=frozenset([1,2,3])  #可变与不可变集合混合运算，返回结果类型以运算符左侧为主

# s2={3,4,5}

# result=s1.union(s2)
# result=s1 | s2

# result=s1.update(s2)

# print(result,s1)

#差集
# s1={1,2,3}
# s2={3,4,5}

# result=s1.difference(s2)
# result=s1-s2
# result=s1.difference_update(s2)
# print(result,s1)

#判定
#  isdisjoint()两个集合不相交
#  issuperset()一个集合包含另一个集合
#  issubset()一个集合包含于另一个集合

# s1={1,2,3,4,5}
# s2={3,4,5}
# print(s1.isdisjoint(s2))
# print(s1.issuperset(s2))
# print(s1.issubset(s2))
